#include "Timer.h"

using namespace TP;
using namespace TP::Threading;
using namespace TP::Temporizador;

Timer::Timer() {
	_modo = RELOJ;
	_tiempoLimite = _tiempoActual = 0;
}

Timer::Timer(const tiempo_t &segundos, const timer_modo_t &modo) {
	_modo = modo;
	_tiempoLimite = segundos;
}

Timer::~Timer() {
	Finalizar();
}

void Timer::setTiempo(const tiempo_t &segundos) {
	_tiempoLimite = segundos;
}

void Timer::setModo(const timer_modo_t &modo) {
	_modo = modo;
}

void Timer::tarea() {
	time(&_ti);
	_encendido = true;
	while (_encendido) {
		if (__comparar()) {
			time(&_tf);
			if (difftime(_tf, _ti) > salto_tiempo) {
				_tiempoActual += _deltaTiempo;
				time(&_ti);
			}
		}
	}
}

bool Timer::timeOut() const {
	bool res;
	switch (_modo) {
		case ASCENDENTE: res = (_tiempoLimite == _tiempoActual);
			break;
		case DESCENDENTE: res = (!_tiempoActual);
			break;
		default: res = 0;
	}
	return res;
}

void Timer::prender() {
	_tiempoActual = (_modo == DESCENDENTE) ? _tiempoLimite : 0;
	_deltaTiempo = (_modo == DESCENDENTE) ? (salto_tiempo * (-1)) : salto_tiempo;
}

void Timer::apagar() {
	_encendido = false;
	Finalizar();
}

void Timer::resetear() {
	if (_modo == ASCENDENTE || _modo == RELOJ)
		_tiempoActual = 0;
	else if (_modo == DESCENDENTE)
		_tiempoActual = _tiempoLimite;
	time(&_ti);
}

tiempo_t Timer::getTiempo() {
	return _tiempoActual;
}

bool Timer::__compAscendente() {
	return (_tiempoActual < _tiempoLimite);
}

bool Timer::__compDescendente() {
	return (_tiempoActual > 0);
}

bool Timer::__compReloj() {
	return true;
}

bool Timer::__comparar() {
	bool resComp;
	switch (_modo) {
		case ASCENDENTE: resComp = __compAscendente();
			break;
		case DESCENDENTE: resComp = __compDescendente();
			break;
		default: resComp = __compReloj();
			break;
	}
	return resComp;
}